home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / mactcp / mactcpmodule.c < prev    next >
Text File  |  1995-10-23  |  22KB  |  991 lines
  1. /***********************************************************
  2. Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
  3. Amsterdam, The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. #include "allobjects.h"
  26. #include "modsupport.h"        /* For getargs() etc. */
  27.  
  28. #include "macglue.h"
  29. #include "tcpglue.h"
  30.  
  31. #include <Desk.h>
  32.  
  33. /* State of a tcp stream, in the connectionState field */
  34. #define STATE_CLOSED    0
  35. #define STATE_LISTEN    2
  36. #define STATE_ESTAB        8
  37. #define STATE_CWAIT        18
  38.  
  39. /* Python code has an additional reason for asr call: open done */
  40. #define MY_OPEN_DONE    32766
  41.  
  42. static object *ErrorObject;
  43.  
  44. TCPIOCompletionUPP    upp_tcp_done;
  45. TCPNotifyUPP        upp_tcp_asr;
  46. #if 0
  47. UDPIOCompletionUPP    upp_udp_done;
  48. #endif
  49. UDPNotifyUPP        upp_udp_asr;
  50.  
  51. /* ----------------------------------------------------- */
  52. /* Declarations for objects of type MacTCP connection status */
  53.  
  54. typedef struct {
  55.     OB_HEAD
  56.     TCPStatusPB status;
  57. } tcpcsobject;
  58.  
  59. staticforward typeobject Tcpcstype;
  60.  
  61. #define is_tcpcsobject(v)        ((v)->ob_type == &Tcpcstype)
  62.  
  63. /* ---------------------------------------------------------------- */
  64. /* Declarations for objects of type MacTCP global status */
  65.  
  66. #ifdef TCP_GS
  67. typedef struct {
  68.     OB_HEAD
  69.     TCPParam *ptr;
  70. } tcpgsobject;
  71.  
  72. staticforward typeobject Tcpgstype;
  73.  
  74. #define is_tcpgsobject(v)        ((v)->ob_type == &Tcpgstype)
  75. #endif /* TCP_GS */
  76.  
  77. /* ---------------------------------------------------------------- */
  78. /* Declarations for objects of type MacTCP TCP stream */
  79.  
  80. typedef struct {
  81.     OB_HEAD
  82.     TCPiopb iop;
  83.     long localhost;            /* Our IP address */
  84.     short localport;        /* Our port number */
  85.     object *asr;            /* Optional async notification routine */
  86.     int asr_ec;                /* error code parameter to asr */
  87.     int asr_reason;            /* detail for some errors */
  88.     int async_busy;            /* True when completion routine pending */
  89.     int async_err;            /* the error for the async call */
  90. } tcpsobject;
  91.  
  92. staticforward typeobject Tcpstype;
  93.  
  94. #define is_tcpsobject(v)        ((v)->ob_type == &Tcpstype)
  95.  
  96. /* ---------------------------------------------------------------- */
  97. /* Declarations for objects of type MacTCP UDP stream */
  98.  
  99. typedef struct {
  100.     OB_HEAD
  101.     UDPiopb iop;
  102.     object *asr;
  103.     int asr_ec;                /* error code parameter to asr */
  104.     ip_port port;
  105. } udpsobject;
  106.  
  107. staticforward typeobject Udpstype;
  108.  
  109. #define is_udpsobject(v)        ((v)->ob_type == &Udpstype)
  110.  
  111. /* ---------------------------------------------------------------- */
  112.  
  113. static tcpcsobject *
  114. newtcpcsobject(ptr)
  115.     TCPStatusPB *ptr;
  116. {
  117.     tcpcsobject *self;
  118.     
  119.     self = NEWOBJ(tcpcsobject, &Tcpcstype);
  120.     if (self == NULL)
  121.         return NULL;
  122.     self->status = *ptr;
  123.     return self;
  124. }
  125.  
  126. static void
  127. tcpcs_dealloc(self)
  128.     tcpcsobject *self;
  129. {
  130.     DEL(self);
  131. }
  132. /* Code to access structure members by accessing attributes */
  133.  
  134. #include "structmember.h"
  135.  
  136. #define OFF(x) offsetof(TCPStatusPB, x)
  137.  
  138. static struct memberlist tcpcs_memberlist[] = {
  139.     {"remoteHost",         T_ULONG,     OFF(remoteHost),         RO},
  140.     {"remotePort",         T_USHORT,     OFF(remotePort),         RO},
  141.     {"localHost",         T_UINT,     OFF(localHost),         RO},
  142.     {"localPort",         T_USHORT,     OFF(localPort),         RO},
  143.     {"tosFlags",         T_BYTE,     OFF(tosFlags),             RO},
  144. #if 0  /* Bug in header file: cannot access precedence */
  145.     {"precedence"         T_BYTE,     OFF(precedence),         RO},
  146. #endif
  147.     {"connectionState", T_BYTE,     OFF(connectionState),     RO},
  148.     {"sendWindow",         T_USHORT,     OFF(sendWindow),         RO},
  149.     {"rcvWindow",         T_USHORT,     OFF(rcvWindow),         RO},
  150.     {"amtUnackedData",     T_USHORT,     OFF(amtUnackedData),     RO},
  151.     {"amtUnreadData",     T_USHORT,     OFF(amtUnreadData),     RO},
  152.     {"sendUnacked",        T_UINT,     OFF(sendUnacked),         RO},
  153.     {"sendNext",         T_UINT,     OFF(sendNext),             RO},
  154.     {"congestionWindow", T_UINT,     OFF(congestionWindow),     RO},
  155.     {"rcvNext",         T_UINT,     OFF(rcvNext),             RO},
  156.     {"srtt",             T_UINT,     OFF(srtt),                 RO},
  157.     {"lastRTT",            T_UINT,        OFF(lastRTT),            RO},
  158.     {"sendMaxSegSize",    T_UINT,        OFF(sendMaxSegSize),    RO},
  159.     {NULL}    /* Sentinel */
  160. };
  161.  
  162. static object *
  163. tcpcs_getattr(self, name)
  164.     tcpcsobject *self;
  165.     char *name;
  166. {
  167.     return getmember((char *)&self->status, tcpcs_memberlist, name);
  168. }
  169.  
  170.  
  171. static typeobject Tcpcstype = {
  172.     OB_HEAD_INIT(&Typetype)
  173.     0,                            /*ob_size*/
  174.     "MacTCP connection status",    /*tp_name*/
  175.     sizeof(tcpcsobject),        /*tp_basicsize*/
  176.     0,                            /*tp_itemsize*/
  177.     /* methods */
  178.     (destructor)tcpcs_dealloc,    /*tp_dealloc*/
  179.     (printfunc)0,                /*tp_print*/
  180.     (getattrfunc)tcpcs_getattr,    /*tp_getattr*/
  181.     (setattrfunc)0,                /*tp_setattr*/
  182.     (cmpfunc)0,                    /*tp_compare*/
  183.     (reprfunc)0,                /*tp_repr*/
  184.     0,                            /*tp_as_number*/
  185.     0,                            /*tp_as_sequence*/
  186.     0,                            /*tp_as_mapping*/
  187.     (hashfunc)0,                /*tp_hash*/
  188. };
  189.  
  190. /* End of code for MacTCP connection status objects */
  191. /* -------------------------------------------------------- */
  192.  
  193. #ifdef TCP_GS
  194. static tcpgsobject *
  195. newtcpgsobject(ptr)
  196.     TCPParam *ptr;
  197. {
  198.     tcpgsobject *self;
  199.     
  200.     self = NEWOBJ(tcpgsobject, &Tcpgstype);
  201.     if (self == NULL)
  202.         return NULL;
  203.     self->ptr = ptr;
  204.     return self;
  205. }
  206.  
  207. static void
  208. tcpgs_dealloc(self)
  209.     tcpgsobject *self;
  210. {
  211.     DEL(self);
  212. }
  213. /* Code to access structure members by accessing attributes */
  214. #undef OFF
  215. #define OFF(x) offsetof(TCPParam, x)
  216.  
  217. static struct memberlist tcpgs_memberlist[] = {
  218.     {"RtoA",        T_UINT,    OFF(tcpRtoA),        RO},
  219.     {"RtoMin",        T_UINT,    OFF(tcpRtoMin),        RO},
  220.     {"RtoMax",        T_UINT,    OFF(tcpRtoMax),        RO},
  221.     {"MaxSegSize",    T_UINT,    OFF(tcpMaxSegSize),    RO},
  222.     {"MaxConn",        T_UINT,    OFF(tcpMaxConn),    RO},
  223.     {"MaxWindow",    T_UINT,    OFF(tcpMaxWindow),    RO},
  224.     {NULL}    /* Sentinel */
  225. };
  226.  
  227. static object *
  228. tcpgs_getattr(self, name)
  229.     tcpgsobject *self;
  230.     char *name;
  231. {
  232.     object *rv;
  233.     
  234.     return getmember((char *)self->ptr, tcpgs_memberlist, name);
  235. }
  236.  
  237. static typeobject Tcpgstype = {
  238.     OB_HEAD_INIT(&Typetype)
  239.     0,                /*ob_size*/
  240.     "MacTCP global status",            /*tp_name*/
  241.     sizeof(tcpgsobject),        /*tp_basicsize*/
  242.     0,                /*tp_itemsize*/
  243.     /* methods */
  244.     (destructor)tcpgs_dealloc,    /*tp_dealloc*/
  245.     (printfunc)0,        /*tp_print*/
  246.     (getattrfunc)tcpgs_getattr,    /*tp_getattr*/
  247.     (setattrfunc)0,    /*tp_setattr*/
  248.     (cmpfunc)0,        /*tp_compare*/
  249.     (reprfunc)0,        /*tp_repr*/
  250.     0,            /*tp_as_number*/
  251.     0,        /*tp_as_sequence*/
  252.     0,        /*tp_as_mapping*/
  253.     (hashfunc)0,        /*tp_hash*/
  254. };
  255. #endif /* TCP_GS */
  256.  
  257. /* End of code for MacTCP global status objects */
  258. /* -------------------------------------------------------- */
  259.  
  260. static int
  261. tcps_checkstate(self, state, state2)
  262.     tcpsobject *self;
  263.     int state, state2;
  264. {
  265.     OSErr err;
  266.     TCPStatusPB *pb;
  267.     char buf[80];
  268.     
  269.     if ( self->async_busy ) {
  270.         err_setstr(ErrorObject, "Operation not allowed, PassiveOpen in progress");
  271.         return -1;
  272.     }
  273.     if ( state < 0 && state2 < 0 )
  274.         return 0;
  275.     err = xTCPStatus(&self->iop, &pb);
  276.     if ( err ) {
  277.         PyErr_Mac(ErrorObject, err);
  278.         return -1;
  279.     }
  280.     if ( state == pb->connectionState ||
  281.          state2 == pb->connectionState )
  282.          return 0;
  283.     sprintf(buf, "Operation not allowed, connection state=%d", pb->connectionState);
  284.     err_setstr(ErrorObject, buf);
  285.     return -1;
  286. }
  287.  
  288. static int
  289. tcps_asr_safe(arg)
  290.     void *arg;
  291. {
  292.     tcpsobject *self = (tcpsobject *)arg;
  293.     object *args, *rv;
  294.     
  295.     if ( self->asr == None )
  296.         return 0;
  297.     args = mkvalue("(ii)", self->asr_ec, self->asr_reason);
  298.     rv = call_object(self->asr, args);
  299.     DECREF(args);
  300.     if ( rv ) {
  301.         DECREF(rv);
  302.         return 0;
  303.     }
  304.     return -1;
  305. }
  306.  
  307. static pascal void
  308. tcps_asr(str, ec, self, reason, icmp)
  309.     StreamPtr str;
  310.     unsigned short ec;
  311.     tcpsobject *self;
  312.     unsigned short reason;
  313.     struct ICMPReport icmp;
  314. {
  315.     if ( self->asr == None )
  316.         return;
  317.     self->asr_ec = ec;
  318.     self->asr_reason = reason;
  319.     Py_AddPendingCall(tcps_asr_safe, (void *)self);
  320. }
  321.  
  322. static void
  323. tcps_done(pb)
  324.     TCPiopb *pb;
  325. {
  326.     tcpsobject *self = (tcpsobject *)pb->csParam.open.userDataPtr;
  327.     
  328.     if ( pb != &self->iop || !self->async_busy ) {
  329.         /* Oops... problems */
  330.         printf("tcps_done: unexpected call\n");
  331.         return;
  332.     }
  333.     self->async_busy = 0;
  334.     self->async_err = pb->ioResult;
  335.     /* Extension of mactcp semantics: also call asr on open complete */
  336.     if ( self->asr == None )
  337.         return;
  338.     self->asr_ec = MY_OPEN_DONE;
  339.     self->asr_reason = 0;
  340.     Py_AddPendingCall(tcps_asr_safe, (void *)self);
  341. }
  342.  
  343. static object *
  344. tcps_isdone(self, args)
  345.     tcpsobject *self;
  346.     object *args;
  347. {
  348.     if (!newgetargs(args, ""))
  349.         return NULL;
  350.     return newintobject(!self->async_busy);
  351. }
  352.  
  353. static object *
  354. tcps_wait(self, args)
  355.     tcpsobject *self;
  356.     object *args;
  357. {
  358.     if (!newgetargs(args, ""))
  359.         return NULL;
  360.     while ( self->async_busy ) {
  361.         if ( PyMac_Idle() ) {
  362.             INCREF(None);
  363.             return None;
  364.         }
  365.     }
  366.     if ( self->async_err ) {
  367.         PyErr_Mac(ErrorObject, self->async_err);
  368.         self->async_err = 0;
  369.         return NULL;
  370.     }
  371.     INCREF(None);
  372.     return None;
  373. }
  374.  
  375.  
  376. static object *
  377. tcps_PassiveOpen(self, args)
  378.     tcpsobject *self;
  379.     object *args;
  380. {
  381.     short port;
  382.     OSErr err;
  383.     
  384.     if (!newgetargs(args, "h", &port))
  385.         return NULL;
  386.     if ( tcps_checkstate(self, -1, -1) < 0 )
  387.         return NULL;
  388.     self->async_busy = 1;
  389.     self->async_err = 0;
  390.     err = xTCPPassiveOpen(&self->iop, port, upp_tcp_done,
  391.                          (void *)self);
  392.     if ( err ) {
  393.         self->async_busy = 0;
  394.         PyErr_Mac(ErrorObject, err);
  395.         return NULL;
  396.     }
  397.     self->localhost = self->iop.csParam.open.localHost;
  398.     self->localport = self->iop.csParam.open.localPort;
  399.     INCREF(None);
  400.     return None;
  401. }
  402.  
  403. static object *
  404. tcps_ActiveOpen(self, args)
  405.     tcpsobject *self;
  406.     object *args;
  407. {
  408.     short lport, rport;
  409.     long rhost;
  410.     OSErr err;
  411.     
  412.     if (!newgetargs(args, "hlh", &lport, &rhost, &rport))
  413.         return NULL;
  414.     if ( tcps_checkstate(self, -1, -1) < 0 )
  415.         return NULL;
  416.     err = xTCPActiveOpen(&self->iop, lport, rhost, rport, (TCPIOCompletionUPP)0);
  417.     if ( err ) {
  418.         PyErr_Mac(ErrorObject, err);
  419.         return NULL;
  420.     }    
  421.     self->localhost = self->iop.csParam.open.localHost;
  422.     self->localport = self->iop.csParam.open.localPort;
  423.     INCREF(None);
  424.     return None;
  425. }
  426.  
  427. static object *
  428. tcps_Send(self, args)
  429.     tcpsobject *self;
  430.     object *args;
  431. {
  432.     char *buf;
  433.     int bufsize;
  434.     int push = 0, urgent = 0;
  435.     OSErr err;
  436.     miniwds wds;
  437.     
  438.     if (!newgetargs(args, "s#|ii", &buf, &bufsize, &push, &urgent))
  439.         return NULL;
  440.     if ( tcps_checkstate(self, STATE_ESTAB, STATE_CWAIT) < 0 )
  441.         return NULL;
  442.     wds.length = bufsize;
  443.     wds.ptr = buf;
  444.     wds.terminus = 0;
  445.     err = xTCPSend(&self->iop, (wdsEntry *)&wds, (Boolean)push, (Boolean)urgent,
  446.                     (TCPIOCompletionUPP)0);
  447.     if ( err ) {
  448.         PyErr_Mac(ErrorObject, err);
  449.         return NULL;
  450.     }
  451.     INCREF(None);
  452.     return None;
  453. }
  454.  
  455. static object *
  456. tcps_Rcv(self, args)
  457.     tcpsobject *self;
  458.     object *args;
  459. {
  460.     int timeout;
  461.     rdsEntry rds[2];
  462.     OSErr err;
  463.     object *rv;
  464.     int urgent, mark;
  465.     
  466.     if (!newgetargs(args, "i", &timeout))
  467.         return NULL;
  468.     if ( tcps_checkstate(self, -1, -1) < 0 )
  469.         return NULL;
  470.     memset((char *)&rds, 0, sizeof(rds));
  471.     err = xTCPNoCopyRcv(&self->iop, rds, 1, timeout, (TCPIOCompletionUPP)0);
  472.     if ( err ) {
  473.         PyErr_Mac(ErrorObject, err);
  474.         return NULL;
  475.     }
  476.     urgent = self->iop.csParam.receive.urgentFlag;
  477.     mark = self->iop.csParam.receive.markFlag;
  478.     rv = newsizedstringobject((char *)rds[0].ptr, rds[0].length);
  479.     err = xTCPBufReturn(&self->iop, rds, (TCPIOCompletionUPP)0);
  480.     if ( err ) {
  481.         /* Should not happen */printf("mactcp module: BufReturn failed?\n");
  482.         PyErr_Mac(ErrorObject, err);
  483.         DECREF(rv);
  484.         return NULL;
  485.     }
  486.     return mkvalue("(Oii)", rv, urgent, mark);
  487. }
  488.  
  489. static object *
  490. tcps_Close(self, args)
  491.     tcpsobject *self;
  492.     object *args;
  493. {
  494.     OSErr err;
  495.     
  496.     if (!newgetargs(args, ""))
  497.         return NULL;
  498.     err = xTCPClose(&self->iop, (TCPIOCompletionUPP)0);
  499.     if ( err ) {
  500.         PyErr_Mac(ErrorObject, err);
  501.         return NULL;
  502.     }
  503.     INCREF(None);
  504.     return None;
  505. }
  506.  
  507. static object *
  508. tcps_Abort(self, args)
  509.     tcpsobject *self;
  510.     object *args;
  511. {
  512.     OSErr err;
  513.     
  514.     if (!newgetargs(args, ""))
  515.         return NULL;
  516.     err = xTCPAbort(&self->iop);
  517.     if ( err ) {
  518.         PyErr_Mac(ErrorObject, err);
  519.         return NULL;
  520.     }
  521.     INCREF(None);
  522.     return None;
  523. }
  524.  
  525. static object *
  526. tcps_Status(self, args)
  527.     tcpsobject *self;
  528.     object *args;
  529. {
  530.     OSErr err;
  531.     TCPStatusPB *pb;
  532.     
  533.     if (!newgetargs(args, ""))
  534.         return NULL;
  535.     if ( tcps_checkstate(self, -1, -1) < 0 )
  536.         return NULL;
  537.     err = xTCPStatus(&self->iop, &pb);
  538.     if ( err ) {
  539.         PyErr_Mac(ErrorObject, err);
  540.         return NULL;
  541.     }
  542.     return (object *)newtcpcsobject(pb);
  543. }
  544.  
  545. static object *
  546. tcps_GetSockName(self, args)
  547.     tcpsobject *self;
  548.     object *args;
  549. {
  550.     /* This routine is needed so we can get at the local port even when
  551.     ** a PassiveOpen is in progress (when we can't do a Status call).
  552.     ** This is needed for socket listen(); getsockname(); accept() emulation
  553.     ** as used by ftp and the like.
  554.     */    
  555.     if (!newgetargs(args, ""))
  556.         return NULL;
  557.     return mkvalue("(lh)", self->localhost, self->localport);
  558. }
  559.  
  560. static struct methodlist tcps_methods[] = {
  561.     {"isdone",    (method)tcps_isdone,    1},
  562.     {"wait",    (method)tcps_wait,        1},
  563.     {"PassiveOpen",    (method)tcps_PassiveOpen,    1},
  564.     {"ActiveOpen",    (method)tcps_ActiveOpen,    1},
  565.     {"Send",    (method)tcps_Send,    1},
  566.     {"Rcv",    (method)tcps_Rcv,    1},
  567.     {"Close",    (method)tcps_Close,    1},
  568.     {"Abort",    (method)tcps_Abort,    1},
  569.     {"Status",    (method)tcps_Status,    1},
  570.     {"GetSockName", (method)tcps_GetSockName, 1},
  571.     {NULL,        NULL}        /* sentinel */
  572. };
  573.  
  574. /* ---------- */
  575.  
  576. static object *
  577. tcps_getattr(self, name)
  578.     tcpsobject *self;
  579.     char *name;
  580. {
  581.     if ( strcmp(name, "asr") == 0 ) {
  582.         INCREF(self->asr);
  583.         return self->asr;
  584.     }
  585.     return findmethod(tcps_methods, (object *)self, name);
  586. }
  587.  
  588. static int
  589. tcps_setattr(self, name, value)
  590.     tcpsobject *self;
  591.     char *name;
  592.     object *value;
  593. {
  594.     if ( strcmp(name, "asr") != 0 || value == NULL )
  595.         return -1;
  596.     self->asr = value;    /* XXXX Assuming I don't have to incref */
  597.     return 0;
  598. }
  599.  
  600. static tcpsobject *
  601. newtcpsobject(bufsize)
  602.     int bufsize;
  603. {
  604.     tcpsobject *self;
  605.     OSErr err;
  606.     
  607.     self = NEWOBJ(tcpsobject, &Tcpstype);
  608.     if (self == NULL)
  609.         return NULL;
  610.     memset((char *)&self->iop, 0, sizeof(self->iop));
  611.     err= xTCPCreate(bufsize, upp_tcp_asr, (void *)self, &self->iop);
  612.     if ( err ) {
  613.         DEL(self);
  614.         PyErr_Mac(ErrorObject, err);
  615.         return NULL;
  616.     }
  617.     INCREF(None);
  618.     self->localhost = 0;
  619.     self->localport = 0;
  620.     self->asr = None;
  621.     self->async_busy = 0;
  622.     self->async_err = 0;
  623.     return self;
  624. }
  625.  
  626. static void
  627. tcps_dealloc(self)
  628.     tcpsobject *self;
  629. {
  630.     if ( self->async_busy ) {
  631.         printf("mactcp module: error: dealloc with async busy\n");
  632.         return;
  633.     }
  634.     xTCPRelease(&self->iop);
  635.     DEL(self);
  636. }
  637.  
  638. static typeobject Tcpstype = {
  639.     OB_HEAD_INIT(&Typetype)
  640.     0,                            /*ob_size*/
  641.     "MacTCP TCP stream",        /*tp_name*/
  642.     sizeof(tcpsobject),            /*tp_basicsize*/
  643.     0,                            /*tp_itemsize*/
  644.     /* methods */
  645.     (destructor)tcps_dealloc,    /*tp_dealloc*/
  646.     (printfunc)0,                /*tp_print*/
  647.     (getattrfunc)tcps_getattr,    /*tp_getattr*/
  648.     (setattrfunc)tcps_setattr,    /*tp_setattr*/
  649.     (cmpfunc)0,                    /*tp_compare*/
  650.     (reprfunc)0,                /*tp_repr*/
  651.     0,                            /*tp_as_number*/
  652.     0,                            /*tp_as_sequence*/
  653.     0,                            /*tp_as_mapping*/
  654.     (hashfunc)0,                /*tp_hash*/
  655. };
  656.  
  657. /* End of code for MacTCP TCP stream objects */
  658. /* -------------------------------------------------------- */
  659.  
  660. static int
  661. udps_asr_safe(arg)
  662.     void *arg;
  663. {
  664.     udpsobject *self = (udpsobject *)arg;
  665.     object *args, *rv;
  666.     
  667.     if ( self->asr == None )
  668.         return 0;
  669.     args = mkvalue("(i)", self->asr_ec);
  670.     rv = call_object(self->asr, args);
  671.     DECREF(args);
  672.     if ( rv ) {
  673.         DECREF(rv);
  674.         return 0;
  675.     }
  676.     return -1;
  677. }
  678.  
  679. static pascal void
  680. udps_asr(str, ec, self, icmp)
  681.     StreamPtr str;
  682.     unsigned short ec;
  683.     udpsobject *self;
  684.     struct ICMPReport icmp;
  685. {
  686.     if ( self->asr == None )
  687.         return;
  688.     self->asr_ec = ec;
  689.     Py_AddPendingCall(udps_asr_safe, (void *)self);
  690. }
  691.  
  692.  
  693. static object *
  694. udps_Read(self, args)
  695.     udpsobject *self;
  696.     object *args;
  697. {
  698.     OSErr err;
  699.     object *rv;
  700.     int timeout;
  701.     
  702.     if (!newgetargs(args, "i", &timeout))
  703.         return NULL;
  704.     err = xUDPRead(&self->iop, timeout, (UDPIOCompletionUPP)0);
  705.     if ( err ) {
  706.         PyErr_Mac(ErrorObject, err);
  707.         return NULL;
  708.     }
  709.     rv = newsizedstringobject((char *)self->iop.csParam.receive.rcvBuff,
  710.                                 self->iop.csParam.receive.rcvBuffLen);
  711.     err = xUDPBfrReturn(&self->iop, self->iop.csParam.receive.rcvBuff);
  712.     if ( err ) {
  713.         PyErr_Mac(ErrorObject, err);
  714.         DECREF(rv);
  715.         return NULL;
  716.     }
  717.     return rv;
  718. }
  719.  
  720. static object *
  721. udps_Write(self, args)
  722.     udpsobject *self;
  723.     object *args;
  724. {
  725.     unsigned long host;
  726.     unsigned short port;
  727.     char *buf;
  728.     int bufsize;
  729.     OSErr err;
  730.     miniwds wds;
  731.     
  732.     if (!newgetargs(args, "lhs#", &host, &port, &buf, &bufsize))
  733.         return NULL;
  734.     wds.length = bufsize;
  735.     wds.ptr = buf;
  736.     wds.terminus = 0;
  737.     err = xUDPWrite(&self->iop, host, port, &wds, (UDPIOCompletionUPP)0);
  738.     if ( err ) {
  739.         PyErr_Mac(ErrorObject, err);
  740.         return NULL;
  741.     }
  742.     INCREF(None);
  743.     return None;
  744. }
  745. static struct methodlist udps_methods[] = {
  746.     {"Read",    (method)udps_Read,    1},
  747.     {"Write",    (method)udps_Write,    1},
  748.  
  749.     {NULL,        NULL}        /* sentinel */
  750. };
  751.  
  752. /* ---------- */
  753.  
  754. static object *
  755. udps_getattr(self, name)
  756.     udpsobject *self;
  757.     char *name;
  758. {
  759.     if ( strcmp(name, "asr") == 0 ) {
  760.         INCREF(self->asr);
  761.         return self->asr;
  762.     }
  763.     if ( strcmp(name, "port") == 0 ) 
  764.         return newintobject((int)self->port);
  765.     return findmethod(udps_methods, (object *)self, name);
  766. }
  767.  
  768. static int
  769. udps_setattr(self, name, value)
  770.     udpsobject *self;
  771.     char *name;
  772.     object *value;
  773. {
  774.     if ( strcmp(name, "asr") != 0 || value == NULL )
  775.         return -1;
  776.     self->asr = value;    /* XXXX Assuming I don't have to incref */
  777.     return 0;
  778. }
  779.  
  780. static udpsobject *
  781. newudpsobject(bufsize, port)
  782.     int bufsize;
  783.     int port;
  784. {
  785.     udpsobject *self;
  786.     OSErr err;
  787.     
  788.     self = NEWOBJ(udpsobject, &Udpstype);
  789.     if (self == NULL)
  790.         return NULL;
  791.     memset((char *)&self->iop, 0, sizeof(self->iop));
  792.     self->port = port;
  793.     err= xUDPCreate(&self->iop, bufsize, &self->port, upp_udp_asr,
  794.                      (void *)self);
  795.     if ( err ) {
  796.         DEL(self);
  797.         PyErr_Mac(ErrorObject, err);
  798.         return NULL;
  799.     }
  800.     INCREF(None);
  801.     self->asr = None;
  802.     return self;
  803. }
  804.  
  805. static void
  806. udps_dealloc(self)
  807.     udpsobject *self;
  808. {
  809.     xUDPRelease(&self->iop);
  810.     DEL(self);
  811. }
  812.  
  813. static typeobject Udpstype = {
  814.     OB_HEAD_INIT(&Typetype)
  815.     0,                            /*ob_size*/
  816.     "MacTCP UDP stream",        /*tp_name*/
  817.     sizeof(udpsobject),            /*tp_basicsize*/
  818.     0,                            /*tp_itemsize*/
  819.     /* methods */
  820.     (destructor)udps_dealloc,    /*tp_dealloc*/
  821.     (printfunc)0,                /*tp_print*/
  822.     (getattrfunc)udps_getattr,    /*tp_getattr*/
  823.     (setattrfunc)udps_setattr,    /*tp_setattr*/
  824.     (cmpfunc)0,                    /*tp_compare*/
  825.     (reprfunc)0,                /*tp_repr*/
  826.     0,                            /*tp_as_number*/
  827.     0,                            /*tp_as_sequence*/
  828.     0,                            /*tp_as_mapping*/
  829.     (hashfunc)0,                /*tp_hash*/
  830. };
  831.  
  832. /* End of code for MacTCP UDP stream objects */
  833. /* -------------------------------------------------------- */
  834.  
  835. static object *
  836. mactcp_TCPCreate(self, args)
  837.     object *self;    /* Not used */
  838.     object *args;
  839. {
  840.     OSErr err;
  841.     object *rv;
  842.     int bufsize;
  843.  
  844.     if (!newgetargs(args, "i", &bufsize))
  845.         return NULL;
  846.     if ( (err = xOpenDriver()) != noErr ) {
  847.         PyErr_Mac(ErrorObject, err);
  848.         return NULL;
  849.     }
  850.     rv = (object *)newtcpsobject(bufsize);
  851.     return rv;
  852. }
  853.  
  854. static object *
  855. mactcp_UDPCreate(self, args)
  856.     object *self;    /* Not used */
  857.     object *args;
  858. {
  859.     OSErr err;
  860.     object *rv;
  861.     int bufsize, port;
  862.  
  863.     if (!newgetargs(args, "ii", &bufsize, &port))
  864.         return NULL;
  865.     if ( (err = xOpenDriver()) != noErr ) {
  866.         PyErr_Mac(ErrorObject, err);
  867.         return NULL;
  868.     }
  869.     rv = (object *)newudpsobject(bufsize, port);
  870.     return rv;
  871. }
  872.  
  873. static object *
  874. mactcp_MTU(self, args)
  875.     object *self;    /* Not used */
  876.     object *args;
  877. {
  878.     OSErr err;
  879.     unsigned short mtu;
  880.  
  881.     if (!newgetargs(args, ""))
  882.         return NULL;
  883.     if ( (err = xOpenDriver()) != noErr ) {
  884.         PyErr_Mac(ErrorObject, err);
  885.         return NULL;
  886.     }
  887.     mtu = xMaxMTU();
  888.     return newintobject((int)mtu);
  889. }
  890.  
  891. static object *
  892. mactcp_IPAddr(self, args)
  893.     object *self;    /* Not used */
  894.     object *args;
  895. {
  896.     OSErr err;
  897.     unsigned long rv;
  898.  
  899.     if (!newgetargs(args, ""))
  900.         return NULL;
  901.     if ( (err = xOpenDriver()) != noErr ) {
  902.         PyErr_Mac(ErrorObject, err);
  903.         return NULL;
  904.     }
  905.     rv = xIPAddr();
  906.     return newintobject((int)rv);
  907. }
  908.  
  909. static object *
  910. mactcp_NetMask(self, args)
  911.     object *self;    /* Not used */
  912.     object *args;
  913. {
  914.     OSErr err;
  915.     unsigned long rv;
  916.  
  917.     if (!newgetargs(args, ""))
  918.         return NULL;
  919.     if ( (err = xOpenDriver()) != noErr ) {
  920.         PyErr_Mac(ErrorObject, err);
  921.         return NULL;
  922.     }
  923.     rv = xNetMask();
  924.     return newintobject((int)rv);
  925. }
  926.  
  927. #ifdef TCP_GS
  928. static object *
  929. mactcp_GlobalInfo(self, args)
  930.     object *self;    /* Not used */
  931.     object *args;
  932. {
  933.     OSErr err;
  934.  
  935.     if (!newgetargs(args, ""))
  936.         return NULL;
  937.     if ( (err = xOpenDriver()) != noErr ) {
  938.         PyErr_Mac(ErrorObject, err);
  939.         return NULL;
  940.     }
  941.     /* XXXX Allocate, fill */
  942.     INCREF(None);
  943.     return None;
  944. }
  945. #endif /* TCP_GS */
  946.  
  947. /* List of methods defined in the module */
  948.  
  949. static struct methodlist mactcp_methods[] = {
  950.     {"TCPCreate",    mactcp_TCPCreate,    1},
  951.     {"UDPCreate",    mactcp_UDPCreate,    1},
  952.     {"MTU",            mactcp_MTU,    1},
  953.     {"IPAddr",        mactcp_IPAddr,    1},
  954.     {"NetMask",        mactcp_NetMask,    1},
  955. #ifdef TCP_GS
  956.     {"GlobalInfo",    mactcp_GlobalInfo,    1},
  957. #endif
  958.  
  959.     {NULL,        NULL}        /* sentinel */
  960. };
  961.  
  962.  
  963. /* Initialization function for the module (*must* be called initmactcp) */
  964.  
  965. void
  966. initmactcp()
  967. {
  968.     object *m, *d;
  969.  
  970.     /* Create the module and add the functions */
  971.     m = initmodule("mactcp", mactcp_methods);
  972.  
  973.     /* Add some symbolic constants to the module */
  974.     d = getmoduledict(m);
  975.     ErrorObject = newstringobject("mactcp.error");
  976.     dictinsert(d, "error", ErrorObject);
  977.     
  978.     upp_tcp_done = NewTCPIOCompletionProc(tcps_done);
  979.     upp_tcp_asr = NewTCPNotifyProc(tcps_asr);
  980. #if 0
  981.     upp_udp_done = NewUDPIOCompletionProc(udps_done);
  982. #endif
  983.     upp_udp_asr = NewUDPNotifyProc(udps_asr);
  984.  
  985.     /* XXXX Add constants here */
  986.     
  987.     /* Check for errors */
  988.     if (err_occurred())
  989.         fatal("can't initialize module mactcp");
  990. }
  991.